package com.browsesoft;

import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.rmi.server.UnicastRemoteObject;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.aote.entity.EntityType;
import com.aote.entity.EntityTypeFactory;
import com.aote.util.ObjectHelper;
import com.browsesoft.baseadapter.BasicEntity;
import com.browsesoft.baseadapter.SimpleEntity;
import com.browsesoft.dbtools.Complete;
import com.browsesoft.dbtools.DBTools;
import com.browsesoft.htmlcomponent.HTMLPage;
import com.browsesoft.oa.EncryptMachine;
import com.browsesoft.oa.GetEncryptMachineTool;
import com.browsesoft.resource.Resource;
import com.browsesoft.user.Organization;
import com.browsesoft.user.Role;
import com.browsesoft.user.User;

/**
 * 对象管理器，负责装载所有的对象，查找所有的对象
 */
public class EntityManager extends UnicastRemoteObject implements Manager,
		Serializable, EntityManagerRMI {
	/**
	 * 
	 */
	private static final long serialVersionUID = 8687688515346497348L;

	/**
	 * 存放对象的链表
	 */
	private LinkedList objects = new LinkedList();

	/**
	 * 每个请求保存一个对象缓存，以便解决内存与数据库不一致的问题，并部分保证性能。
	 */
	private Map pageManagers = new HashMap();

	/**
	 * 存放类名与表名的对应关系
	 */
	private Map classNameAndTableNames = new HashMap();

	/**
	 * 存放在导入旧系统对象时，需要事后处理的对象
	 */
	private Collection completes = new LinkedList();

	/**
	 * 管理器自己
	 */
	private static EntityManager self;

	public EntityManager() throws Exception {
		self = this;
	}

	/**
	 * 根据属性文件转载所有的对象
	 */
	public void load() throws Exception {
		System.out.println("begin VerifyLicence");
		// 校验licence
		// if (!VerifyLicence.verify("licence.xml") ||
		// !Certificate.certificate()) {
		// System.out.println("invalid licence");
		// return;
		// }
		// 取得文档对象
		Document doc = (Document) PropertiesService.getDocument();
		// 取得对象列表
		NodeList list = doc.getElementsByTagName("entity");
		// 取得实体
		System.out.println("objectmanager length:" + list.getLength());
		Node tag = list.item(0);
		// 取得节点列表
		NodeList children = tag.getChildNodes();
		System.out.println("children length:" + children.getLength());
		for (int i = 0; i < children.getLength(); i++) {
			// 判断节点的类型是否是元素节点
			if (children.item(i).getNodeType() == Node.ELEMENT_NODE) {
				// 取出子节点元素
				Element child = (Element) children.item(i);
				System.out.println("child node element" + child.toString());
				// 创建对象
				createObject(child);
			}
		}
		// 建立关系
		createRelations();
	}

	/**
	 * 实体之间创建关系
	 */
	private void createRelations() {
		// 将对象链表转换成迭代器
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 实体之间创建关系
			((Entity) it.next()).createRelation();
		}
	}

	/**
	 * 根据登录名称得到用户
	 * 
	 * @param username
	 * @return
	 */
	public synchronized SimpleEntity getUserForLoginName(String username)
			throws Exception {
		SimpleEntity se = null;
		LinkedList list = this.getObjects(
				"com.browsesoft.baseadapter.SimpleEntity", "ename", username);
		if (list.size() > 0) {
			se = (SimpleEntity) list.get(0);
		}
		return se;
	}

	/**
	 * 根据ID获取对象
	 * 
	 * @return Object
	 */
	public synchronized Object getObject(String id) {
		// 将对象链表转换成迭代器
		Iterator iterator = objects.iterator();
		while (iterator.hasNext()) {
			// 取出每个尸实体
			Entity entity = (Entity) iterator.next();
			try {
				// 判断是否是要得实体，是则返回
				if (entity.getID().equals(id)) {
					return entity;
				}
			} catch (Exception e) {
				throw new RuntimeException(entity.getAttributes().toString());
			}
		}
		return null;
	}

	/**
	 * 根据属性名=属性值对查找，在常驻对象中查找
	 * 
	 * @param className
	 *            要查找的对象类型
	 */
	public synchronized LinkedList getObjectsInResident(String className,
			Hashtable ht) {
		try {
			LinkedList list = new LinkedList();
			// 将链表转换成迭代器
			Iterator it = objects.iterator();
			while (it.hasNext()) {
				// 取出实体
				Entity entity = (Entity) it.next();
				// 判断是否是要的实体
				if (Class.forName(className).isInstance(entity)) {
					// 取出实体的属性命和属性值判断和登录名，密码是否相符
					if (isSame(entity, ht)) {
						list.add(entity);
					}
				}
			}
			return list;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 根据属性名=属性值对查找
	 * 
	 * @param className
	 *            要查找的对象类型
	 */
	public synchronized LinkedList getObjects(String className, Hashtable ht)
			throws Exception {
		LinkedList list = new LinkedList();
		// 将链表转换成迭代器
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取出实体
			Entity entity = (Entity) it.next();
			// 判断是否是要的实体
			if (Class.forName(className).isInstance(entity)) {
				// 取出实体的属性命和属性值判断和登录名，密码是否相符
				if (isSame(entity, ht)) {
					list.add(entity);
				}
			}
		}
		// 根据类名得到所有要延迟加载的表名
		Iterator iter = EntityTypeFactory.getInstance()
				.getTableNamesByClassName(className);
		// 如果有要延迟加载的表
		if (iter.hasNext()) {
			list.addAll(this.getObject(iter, className, ht));
		}
		// 返回迭代器
		return list;
	}

	/**
	 * 根据Map条件，找实体，如果实体没有加载，根据element提供的信息加载
	 */
	public List getEntities(String entityType, Map ht, Element element) {
		// 如果得不到实体描述
		if (!EntityTypeFactory.getInstance().contains(entityType)) {
			// 根据元素加载对象
			String table = element.getAttribute("tablename");
			String className = element.getAttribute("model");
			String types = element.getAttribute("entitytype");
			String lazy = element.getAttribute("isLazy");
			this.createObject(element, table, className, types, lazy);
		}
		return this.getEntities(entityType, new Hashtable(ht));
	}

	/**
	 * 根据单一条件，找实体，如果实体没有加载，根据element提供的信息加载
	 */
	public List getEntities(String entityType, String name, String value,
			Element element) {
		Map ht = new HashMap();
		ht.put(name, value);
		return this.getEntities(entityType, ht, element);
	}

	/**
	 * 找实体的所有对象，如果实体没有加载，根据element提供的信息加载
	 */
	public List getEntities(String entityType, Element element) {
		Map ht = new HashMap();
		return this.getEntities(entityType, ht, element);
	}

	/**
	 * 根据属性名=属性值对查找
	 * 
	 */
	public LinkedList getEntities(String entityType, Hashtable ht) {
		LinkedList list = new LinkedList();
		// 将链表转换成迭代器
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取出实体
			Entity entity = (Entity) it.next();
			// 判断是否是要的实体
			if (entity instanceof BasicEntity) {
				String type = ((BasicEntity) entity).getEntityType();
				// 取出实体的属性命和属性值判断和登录名，密码是否相符
				if (type != null && type.equals(entityType)
						&& isSame(entity, ht)) {
					list.add(entity);
				}
			}
		}
		return list;
	}

	/**
	 * 取得部分属性相同的对象 根据属性名=属性值对查找 或的关系，有一个 属性名=属性值对 就可以
	 * 
	 * @param className
	 *            要查找的对象类型
	 */
	public LinkedList getPartObjects(String className, Hashtable ht)
			throws Exception {
		LinkedList list = new LinkedList();
		// 将链表转换成迭代器
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取出实体
			Entity entity = (Entity) it.next();
			// 判断是否是要的实体
			if (Class.forName(className).isInstance(entity)) {
				// 取出实体的属性命和属性值判断和登录名，密码是否相符
				if (isPartSame(entity, ht)) {
					list.add(entity);
				}
			}
		}
		// 根据类名得到所有要延迟加载的表名
		Iterator iter = EntityTypeFactory.getInstance()
				.getTableNamesByClassName(className);
		// 如果有要延迟加载的表
		if (iter.hasNext()) {
			list.addAll(this.getObject(iter, className, ht));
		}
		// 返回迭代器
		return list;
	}

	/**
	 * 根据属性名=属性值对查找
	 * 
	 * @param className
	 *            要查找的对象类型
	 */
	public synchronized LinkedList getObjects(String className, Hashtable ht,
			boolean cases) throws Exception {
		LinkedList list = new LinkedList();
		// 将链表转换成迭代器
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取出实体
			Entity entity = (Entity) it.next();
			// 判断是否是要的实体
			if (Class.forName(className).isInstance(entity)) {
				// 取出实体的属性命和属性值判断和登录名，密码是否相符
				if (isSame(entity, ht, cases)) {
					list.add(entity);
				}
			}
		}
		// 根据类名得到所有要延迟加载的表名
		Iterator iter = EntityTypeFactory.getInstance()
				.getTableNamesByClassName(className);
		// 如果有要延迟加载的表
		if (iter.hasNext()) {
			list.addAll(this.getObject(iter, className, ht));
		}
		// 返回迭代器
		return list;
	}

	/**
	 * 根据表名得到对象
	 */
	private synchronized LinkedList getObject(Iterator names, String classname,
			Hashtable ht) {
		LinkedList result = new LinkedList();
		while (names.hasNext()) {
			// 返回延迟装载结果
			result.addAll(this.loadEntities(classname, (String) names.next(),
					ht));
		}
		return result;
	}

	/**
	 * 根据类名和条件延迟加载对象
	 * 
	 * @param className
	 *            类名
	 * @param tableName
	 *            表名
	 * @param condition
	 *            条件
	 * @return 加载的对象列表
	 */
	private Collection loadEntities(String className, String tableName,
			Map condition) {
		try {
			// 产生sql语句
			String sql = "select * from " + tableName;
			// 如果有条件
			String sqlCondition = DBTools
					.hashtableToSQLLikeCondition(condition);
			if (!sqlCondition.equals("")) {
				// 添加条件
				sql += " where " + sqlCondition;
			}
			// 得到结果
			String[][] data = DBTools.executeQueryWithTableHead(sql);
			return ObjectHelper.newObjects(data, className);
		} catch (SQLException e) {
			System.out.println(e.getMessage());
			return new LinkedList();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 得到某种类型的所有实体
	 */
	public synchronized LinkedList getObjects(String className)
			throws Exception {
		Hashtable condition = new Hashtable();
		return this.getObjects(className, condition);
	}

	/**
	 * 根据属性名=属性值查找
	 * 
	 * @param className
	 *            要查找的对象类型
	 * @param name
	 *            属性名
	 * @param value 属性值 return 找到的对象列表
	 */
	public synchronized LinkedList getObjects(String className, String name,
			String value) throws Exception {
		Hashtable attrs = new Hashtable();
		attrs.put(name, value);
		return this.getObjects(className, attrs);
	}

	/**
	 * 根据属性名=属性值查找
	 * 
	 * @param name
	 *            属性名
	 * @param value 属性值 return 找到的对象列表
	 */
	public LinkedList getEntities(String entityType, String name, String value) {
		Hashtable attrs = new Hashtable();
		attrs.put(name, value);
		return this.getEntities(entityType, attrs);
	}

	/**
	 * 根据属性名=属性值找单个对象
	 */
	public Entity getEntity(String entityType, String name, String value) {
		List l = this.getEntities(entityType, name, value);
		// 有值，返回第一个，否则，返回空
		if (l.size() > 0) {
			return (Entity) l.get(0);
		}
		return null;
	}

	/**
	 * 根据多个属性名=属性值对从数据库查找
	 */
	public Collection getEntitiesFromDB(String entityType, Map condition) {
		try {
			// 得到实体类型所对应的表以及类名
			EntityType type = EntityTypeFactory.getInstance().getEntityType(
					entityType);
			String tableName = type.getTableName();
			// 通过sql语句得到内容
			String sCond = DBTools.hashtableToSQLCondition(condition, false);
			String sql = "select * from " + tableName + " where " + sCond;
			String[][] data = DBTools.executeQueryWithTableHead(sql);
			// 返回将数据转换成对象的结果
			return ObjectHelper.newObjects(data, type.getClassName());
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 根据属性名=属性值从数据库查找
	 * 
	 * @param entityType
	 *            要查找的实体类型
	 * @param name
	 *            属性名
	 * @param value 属性值 return 找到的对象列表
	 */
	public Collection getEntitiesFromDB(String entityType, String name,
			String value) {
		Map cond = new HashMap();
		cond.put(name, value);
		return this.getEntitiesFromDB(entityType, cond);
	}

	/**
	 * 根据属性名=属性值从数据库查找，返回迭代
	 * 
	 * @param entityType
	 *            要查找的实体类型
	 * @param name
	 *            属性名
	 * @param value 属性值 return 找到的对象列表
	 */
	public Iterator getEntities(String entityType, String name, String value,
			DBTools dbtool) {
		// 将单条件转换成条件对查找
		Map map = new HashMap();
		map.put(name, value);
		return this.getEntities(entityType, map, dbtool);
	}

	/**
	 * 根据属性名=属性值从数据库查找，返回迭代
	 * 
	 * @param entityType
	 *            要查找的实体类型
	 */
	public Iterator getEntities(String entityType, Map condition, DBTools dbtool) {
		try {
			// 得到实体类型所对应的表以及类名
			EntityType type = EntityTypeFactory.getInstance().getEntityType(
					entityType);
			String tableName = type.getTableName();
			// 通过sql语句得到内容
			String qcon = DBTools.hashtableToSQLCondition(condition, false);
			qcon = DBTools.connectCondition(qcon, "entitytype='" + entityType
					+ "'");
			String sql = "select * from " + tableName + " where " + qcon;
			ResultSet set = dbtool.querySet(sql);
			// 返回将数据转换成对象的结果
			return new EntityIterator(set, type.getClassName());
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 根据一批属性名=属性值条件查找对象
	 */
	public Collection getEntities(String entityType, Map condition,
			HTMLPage request) {
		try {
			// 得到实体类型
			EntityType type = EntityTypeFactory.getInstance().getEntityType(
					entityType);
			// 如果不是延迟加载
			if (!type.isLazy()) {
				// 得到类名
				String className = type.getClassName();
				Hashtable ht = new Hashtable(condition);
				ht.put("entitytype", entityType);
				return this.getObjectsInResident(className, ht);
			}
			Collection result = new LinkedList();
			// 在内存中查找实体
			result = this.findEntityFromMemory(entityType, condition, request);
			// 如果要查找的实体在内存中
			if (result.size() != 0) {
				return result;
			}
			// 从数据库中查找实体
			result = this.getEntitiesFromDB(entityType, condition);
			// 将得到的实体放入缓冲区
			this.addEntityToBuffer(result, request);
			return result;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 根据属性名=属性值查找实体
	 * 
	 * @param entityType
	 *            要查找的实体类型
	 * @param name
	 *            属性名
	 * @param value 属性值 return 找到的对象列表
	 */
	public Collection getEntities(String entityType, String name, String value,
			HTMLPage request) {
		Map cond = new HashMap();
		cond.put(name, value);
		return this.getEntities(entityType, cond, request);
	}

	/**
	 * 根据请求得到预存对象列表
	 */
	private synchronized Collection getManager(HTMLPage request) {
		// 从映射表中得到
		Collection manager = (Collection) this.pageManagers.get(request);
		// 如果每有找到
		if (manager == null) {
			// 产生新的放进映射表中
			manager = new LinkedList();
			this.pageManagers.put(request, manager);
		}
		return manager;
	}

	/**
	 * 移走失效页面
	 */
	public synchronized void removeInvalidPage() {
		Collection temp = new LinkedList();
		// 对于每一个页面
		Iterator iter = this.pageManagers.keySet().iterator();
		while (iter.hasNext()) {
			HTMLPage item = (HTMLPage) iter.next();
			// 如果失效
			if (item.isInvalid()) {
				temp.add(item);
			}
		}
		// 移走所有失效页面
		iter = temp.iterator();
		while (iter.hasNext()) {
			Object item = iter.next();
			this.pageManagers.remove(item);
		}
	}

	/**
	 * 根据多个属性名=属性值对在内存中找实体
	 */
	private Collection findEntityFromMemory(String entityType, Map condition,
			HTMLPage request) {
		Collection result = new LinkedList();
		// 得到请求所对应的管理器
		Iterator iter = this.getManager(request).iterator();
		while (iter.hasNext()) {
			Entity findObj = (Entity) iter.next();
			// 实体类型
			String entitytype = (String) findObj.getAttributes().get(
					"entitytype");
			// 如果实体类型和属性值与给定的条件相等
			if (entitytype.equals(entityType) && isSame(findObj, condition)) {
				// 放入集合中
				result.add(findObj);
			}
		}
		return result;
	}

	/**
	 * 把不在缓冲区的实体从数据库中取出后放入缓冲区
	 * 
	 * @param result
	 *            ，实体集合
	 */
	private void addEntityToBuffer(Collection result, HTMLPage request) {
		// 得到请求所对应的缓冲区
		Collection buffer = this.getManager(request);
		buffer.addAll(result);
	}

	/**
	 * 根据实体类型以分页方式查找对象
	 * 
	 * @param entityType
	 *            实体类型
	 * @param start 数据开始行号
	 * @param end
	 *            数据结束行号 return 找到的对象列表
	 */
	public Collection getEntities(String entityType, int start, int end) {
		return this.getEntities(entityType, start, end, "");
	}

	/**
	 * 根据实体类型以及条件以分页方式查找对象
	 * 
	 * @param entityType
	 *            实体类型
	 * @param start 数据开始行号
	 * @param end
	 *            数据结束行号
	 * @param condition
	 *            条件 return 找到的对象列表
	 */
	public Collection getEntities(String entityType, int start, int end,
			String condition) {
		// 得到实体类型所对应的表以及类的对应关系
		EntityType type = EntityTypeFactory.getInstance().getEntityType(
				entityType);
		// 从数据库中加载数据
		return this.loadObjects(type.getTableName(), type.getClassName(),
				entityType, start, end, condition);
	}

	/**
	 * 根据实体类型以及条件以分页方式查找对象
	 * 
	 * @param entityType
	 *            实体类型
	 * @param start 数据开始行号
	 * @param end
	 *            数据结束行号
	 * @param condition
	 *            条件 return 找到的对象列表
	 */
	public Collection getEntities(String entityType, int start, int end,
			String condition, String order) {
		// 得到实体类型所对应的表以及类的对应关系
		EntityType type = EntityTypeFactory.getInstance().getEntityType(
				entityType);
		// 从数据库中加载数据
		return this.loadObjects(type.getTableName(), type.getClassName(),
				entityType, start, end, condition, order);
	}

	/**
	 * 根据实体类型以及条件查找对象
	 * 
	 * @param entityType
	 *            实体类型
	 * @param condition
	 *            条件 return 找到的对象列表
	 */
	public Collection getEntities(String entityType, String condition) {
		try {
			// 得到实体类型所对应的表以及类名
			EntityType type = EntityTypeFactory.getInstance().getEntityType(
					entityType);
			String tableName = type.getTableName();
			// 查询条件
			String condi = DBTools.connectCondition(condition, "entitytype='"
					+ entityType + "'");
			// 通过sql语句得到内容
			String sql = "select * from " + tableName + " where " + condi;
			String[][] data = DBTools.executeQueryWithTableHead(sql);
			// 返回将数据转换成对象的结果
			return ObjectHelper.newObjects(data, type.getClassName());
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 根据表名以及条件查找对象
	 * 
	 * @param tablename
	 *            表名
	 * @param condition
	 *            条件 return 找到的对象列表
	 */
	public Collection getEntitiesByTableName(String tablename, String condition) {
		try {
			// 得到表名所对应的类名
			String classname = EntityTypeFactory.getInstance()
					.getClassNameByTableName(tablename);
			// 通过sql语句得到内容
			String sql = "select * from " + tablename + " where " + condition;
			String[][] data = DBTools.executeQueryWithTableHead(sql);
			// 返回将数据转换成对象的结果
			return ObjectHelper.newObjects(data, classname);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 
	 * @return
	 */
	public List getEntities(String tableName, String condition, Class javaClass) {
		try {
			// 通过sql语句得到内容
			String sql = "select * from " + tableName + " where " + condition;
			String[][] data = DBTools.executeQueryWithTableHead(sql);
			// 返回将数据转换成对象的结果
			return ObjectHelper.newObjects(data, javaClass.getName());
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 根据实体类型以及id号得到对象
	 * 
	 * @param entityType
	 *            实体类型
	 * @param id
	 *            实体id
	 * @return 对象
	 */
	public synchronized Entity getObject(String entityType, String id,
			HTMLPage request) {
		Iterator iter = this.getEntities(entityType, "id", id, request)
				.iterator();
		// 如果有对象
		if (iter.hasNext()) {
			// 返回找到的对象
			return (Entity) iter.next();
		}
		// 返回空
		return null;
	}

	/**
	 * 得到某类实体的元素个数
	 * 
	 * @param entityType
	 *            实体类型
	 * @return 实体个数
	 */
	public int getEntityCount(String entityType) {
		return this.getEntityCount(entityType, "");
	}

	/**
	 * 得到所有求和字段的sql语句表示
	 * 
	 * @param names
	 * @return sql语句表示
	 */
	public String getSQLOfSums(Collection names) {
		String result = "";
		Iterator it = names.iterator();
		// 对于每一个
		while (it.hasNext()) {
			// 如果不是第一项
			if (!result.equals("")) {
				// 添加逗号
				result += ',';
			}
			// 拼接求和字段
			result += "sum(" + (String) it.next() + ")";
		}
		return result;
	}

	/**
	 * 把结果中的数字串转换成double数组
	 * 
	 * @param sums
	 *            结果
	 * @return double数组
	 */
	public double[] getDoubleOfSums(String[] sums) {
		// 结果数组
		double[] result = new double[sums.length];
		// 对于每一个
		for (int i = 0; i < sums.length; i++) {
			// 将String转换为double
			try {
				result[i] = Double.parseDouble(sums[i]);
			} catch (NumberFormatException ex) {
				result[i] = 0;
			}
		}
		return result;
	}

	/**
	 * 根据给定的条件得到某实体的个数并对要求的列进行汇总
	 * 
	 * @param entityType
	 *            实体类型
	 * @param condition
	 *            条件
	 * @return 第一项为实体个数，以后各项为各列汇总值
	 */
	public double[] getEntityCountAndSums(String entityType, String condition,
			Collection names) {
		try {
			// 得到实体类型所对应的表
			EntityType type = EntityTypeFactory.getInstance().getEntityType(
					entityType);
			String tableName = type.getTableName();
			String sql = "select count(*)";
			// 取sum的sql
			String sum = this.getSQLOfSums(names);
			// 如果有值
			if (sum != null && !sum.equals("")) {
				sql += "," + sum;
			}
			// 组织sql语句
			sql += " from " + tableName;
			// 得到条件
			String con = "entitytype='" + entityType + "'";
			con = DBTools.connectCondition(con, condition);
			sql += " where " + con;
			// 统计结果
			String[][] data = DBTools.executeQueryWithTableHead(sql);
			return this.getDoubleOfSums(data[1]);
		} catch (SQLException e) {
			System.out.println(e.getMessage());
			return null;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 得到某类实体的元素个数
	 * 
	 * @param entityType
	 *            实体类型
	 * @return 实体个数
	 */
	public int getEntityCount(String entityType, String condition) {
		try {
			// 得到实体类型所对应的表
			EntityType type = EntityTypeFactory.getInstance().getEntityType(
					entityType);
			String tableName = type.getTableName();
			// 组织sql语句
			String sql = "select count(*) from " + tableName;
			// 得到条件
			String con = "entitytype='" + entityType + "'";
			con = DBTools.connectCondition(con, condition);
			sql += " where " + con;
			// 统计结果
			String[][] data = DBTools.executeQueryWithTableHead(sql);
			return Integer.parseInt(data[1][0]);
		} catch (SQLException e) {
			System.out.println(e.getMessage());
			return 0;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 取出实体的属性命和属性值判断和登录名，密码是否相符
	 * 
	 * @param entity
	 *            实体
	 * @param ht
	 * @return boolean
	 */
	public static boolean isSame(Entity entity, Map ht) {
		// 取得对象类型的属性名和属性值
		Iterator enu = ht.keySet().iterator();
		// 遍历哈希表
		while (enu.hasNext()) {
			Object attrName = enu.next();
			// 取出登陆的属性值
			String name1 = (String) ht.get(attrName);
			// 从实体中取出属性值
			String name2 = (String) entity.getAttributes().get(attrName);
			// 判断是否相等
			if (!name1.equals(name2)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 取出实体的属性命和属性值判断和登录名，密码是否相符
	 * 
	 * @param entity
	 *            实体
	 * @param ht
	 * @return boolean
	 */
	private boolean isPartSame(Entity entity, Map ht) {
		// 取得对象类型的属性名和属性值
		Iterator enu = ht.keySet().iterator();
		// 遍历哈希表
		while (enu.hasNext()) {
			Object attrName = enu.next();
			// 取出登陆的属性值
			String name1 = (String) ht.get(attrName);
			// 从实体中取出属性值
			String name2 = (String) entity.getAttributes().get(attrName);
			// 判断是否相等
			if (name1.equals(name2)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 取出实体的属性命和属性值判断和登录名，密码是否相符,不区分大小写
	 * 
	 * @param entity
	 *            实体
	 * @param ht
	 * @return boolean
	 */
	private boolean isSame(Entity entity, Map ht, boolean cases) {
		// 取得加密器
		EncryptMachine em = GetEncryptMachineTool.getEncryptMachine();
		// 取得对象类型的属性名和属性值
		Iterator enu = ht.keySet().iterator();
		// 遍历哈希表
		while (enu.hasNext()) {
			Object attrName = enu.next();
			// 取出登陆的属性值
			String name1 = (String) ht.get(attrName);
			// 从实体中取出属性值
			String name2 = (String) entity.getAttributes().get(attrName);
			// 如果区分大小写
			if (cases) {
				if (attrName.toString().equals("password")) {
					name1 = em.getEncryptData(name1, "userpassword");
					// 如果不相等,返会false
					if (!name1.equals(name2)) {
						return false;
					}
				} else {
					// 判断是否相等
					if (!name1.equals(name2)) {
						return false;
					}
				}
			}
			// 如果不区分大小写
			else {
				if (attrName.toString().equals("password")) {
					// 将数据库中的密码解密
					// name2 = em.getDncodeData(name2);
					String small = em.getEncryptData(name1, "userpassword");
					String big = em.getEncryptData(name1.toUpperCase(),
							"userpassword");
					// 如果不相等,返会false
					if (!small.equals(name2) && !big.equals(name2)) {
						return false;
					}
				} else {
					if (!name1.equalsIgnoreCase(name2)) {
						return false;
					}
				}
			}
		}
		return true;
	}

	/**
	 * 增加对象
	 */
	public synchronized void add(Entity obj) {
		objects.add(obj);
	}

	/**
	 * 删除对象
	 * 
	 */
	public synchronized void remove(Entity obj) {
		objects.remove(obj);
	}

	/**
	 * 采用从元素上得到的具体的值创建对象
	 */
	private void createObject(Element child, String tableName,
			String className, String entityTypes, String isLazy) {
		try {
			EntityTypeFactory.getInstance().addEntities(tableName, className,
					entityTypes, isLazy);
			this.classNameAndTableNames.put(className, tableName);
			// 如果表不存在，不加载
			if (!DBTools.isTableExist(tableName)) {
				return;
			}
			// 如果该表的数据要延迟装载，不加载
			if (isLazy != null && isLazy.equals("isLazy")) {
				return;
			}
			// 产生sql语句
			String sql = "select * from " + tableName;
			System.out.println("加载：" + sql);
			// 得到排序方式
			String orderBy = child.getAttribute("orderby");
			// 如果存在初始排序字段
			if (orderBy != null && !orderBy.equals("")) {
				// 添加排序方式
				sql += " order by " + orderBy;
			}
			// 执行sql语句装载对象
			String[][] data = DBTools.executeQueryWithTableHead(sql);
			// 如果要排序的字段是数字型
			if (child.hasAttribute("number")) {
				// 得到要排序字段所在列
				int col = DBTools.indexOf(data[0], orderBy);
				// 对结果按数字方式排序
				Arrays.sort(data, new NumberComparator(col));
			}
			this.objects.addAll(ObjectHelper.newObjects(data, className));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 创建新的对象
	 */
	private void createObject(Element child) {
		// 得到数据库表名
		String tableName = child.getTagName();
		// 得到类名
		String className = child.getAttribute("classname");
		// 得到实体类型名
		String entityTypes = child.getAttribute("entitytypes");
		// 如果实体类型名为空
		if (entityTypes.equals("")) {
			// 设置为类名
			entityTypes = className;
		}
		// 得到是否延迟加载说明
		String isLazy = child.getAttribute("isLazy");
		this.createObject(child, tableName, className, entityTypes, isLazy);
	}

	/**
	 * 产生新对象
	 * 
	 * @param className
	 *            对象类名
	 * @param hash
	 *            属性值
	 * @return 产生的对象
	 */
	public static Object newObject(String className, Map hash) {
		try {
			// 产生类
			Class c[] = new Class[1];
			c[0] = Class.forName("java.util.Hashtable");
			// 取得对象类的构造函数
			Constructor constr = Class.forName(className).getConstructor(c);
			// 生成新的对象
			Object[] objs = new Object[1];
			objs[0] = hash;
			Object obj = constr.newInstance(objs);
			return obj;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 取得资源的根
	 * 
	 * @return
	 */
	public synchronized Resource getRoot() {
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取得实体
			Entity entity = (Entity) it.next();
			// 判断实体是否是资源
			if (entity instanceof Resource) {
				Resource resource = (Resource) entity;
				// 判断资源的父是否为空，为空则返回根
				if (resource.getParent() == null) {
					return resource;
				}
			}
		}
		return null;
	}

	/**
	 * 得到给定资源的根节点，资源没有嵌套
	 * 
	 * @return 根
	 */
	public synchronized Resource getGivenResourceRoot(String type) {
		Resource root = getRoot();
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取得实体
			Entity entity = (Entity) it.next();
			// 判断实体是否是资源
			if (entity instanceof Resource
					&& ((Resource) entity).getType().equals(type)) {
				Resource resource = (Resource) entity;
				// 判断资源的父是否为空，为空则返回根
				if (resource.getParent() == null
						|| resource.getParent() == root) {
					return resource;
				}
			}
		}
		return null;
	}

	/**
	 * 取得功能的根
	 * 
	 * @return 功能的根
	 */
	public synchronized Resource getRootFunction() {
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取得实体
			Entity entity = (Entity) it.next();
			// 判断实体是否是资源
			if (entity instanceof Resource
					&& ((Resource) entity).getType().equals("function")) {
				Resource resource = (Resource) entity;
				// 判断资源的父是否为空，为空则返回根
				if (!resource.getParent().getType().equals("function")) {
					return resource;
				}
			}
		}
		return null;
	}

	/**
	 * 取得组织的根
	 * 
	 * @return 功能的根
	 */
	public synchronized Resource getRootOrganization() {
		String id;
		try {
			id = PropertiesService
					.getProperty("OrganizationRoot", "resourceId");
		} catch (Exception e) {
			String usage = "<OrganizationRoot resourceId=\"id\"/>";
			throw new RuntimeException("属性文件中必须指定根组织id：" + usage);
		}
		return (Resource) this.getObject(id);
	}

	public synchronized Hashtable getAllUser() {
		Hashtable resources = new Hashtable();
		LinkedList list = new LinkedList();
		Iterator ite = this.objects.iterator();
		while (ite.hasNext()) {
			Entity re = (Entity) ite.next();
			if (re instanceof User) {
				list.add(re);
			}
		}
		resources.clear();
		for (int j = 0; j < list.size(); j++) {
			Resource resource = (Resource) list.get(j);
			resources.put(resource.getID(), resource);
			while (resource.getParent() != null) {
				resource = resource.getParent();
				resources.put(resource.getID(), resource);
			}
		}
		return resources;
	}

	/**
	 * 得到所有角色
	 * 
	 * @return 所有角色链表
	 */
	public synchronized LinkedList getAllRoles() {
		LinkedList list = new LinkedList();
		Iterator ite = this.objects.iterator();
		while (ite.hasNext()) {
			Entity entity = (Entity) ite.next();
			if (entity instanceof Resource) {
				Resource re = (Resource) entity;
				if (re instanceof Role) {
					list.add(re);
				}
			}
		}
		return list;
	}

	/**
	 * 根据角色名称得到角色
	 * 
	 * @param name
	 *            角色名称
	 * @return 角色
	 */
	public synchronized Role getRoleFromName(String name) {
		LinkedList roles = this.getAllRoles();
		for (int i = 0; i < roles.size(); i++) {
			Role role = (Role) roles.get(i);
			if (role.getAttributes().get("name").toString().equals(name)) {
				return role;
			}
		}
		return null;
	}

	/**
	 * 根据角色名称得到角色,实现模糊查找
	 * 
	 * @param name
	 *            角色名称
	 * @return 角色
	 */
	public synchronized LinkedList getRoleFromNameWithBlurSearch(String name) {
		LinkedList result = new LinkedList();
		LinkedList roles = this.getAllRoles();
		for (int i = 0; i < roles.size(); i++) {
			Role role = (Role) roles.get(i);
			String roleName = (String) role.getAttributes().get("name");
			if (roleName.indexOf(name) != -1) {
				result.add(role);
			}
		}
		return result;
	}

	public synchronized Resource getResourceFromName(String name) {
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取得实体
			Entity entity = (Entity) it.next();
			// 判断实体是否是资源
			if (entity instanceof Resource) {
				Resource resource = (Resource) entity;
				if (resource.getAttributes().get("name").toString()
						.equals(name)) {
					return resource;
				}
			}
		}
		return null;
	}

	/**
	 * 根据角色名得角色,实现模糊查找
	 * 
	 * @param name
	 * @return
	 */
	public synchronized LinkedList getResourceFromNameWithBlurSearch(String name) {
		LinkedList result = new LinkedList();
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取得实体
			Entity entity = (Entity) it.next();
			// 判断实体是否是资源
			if (entity instanceof Organization) {
				Resource resource = (Resource) entity;
				String roleName = (String) resource.getAttributes().get("name");
				if (roleName.indexOf(name) != -1) {
					result.add(resource);
				}
			}
		}
		return result;
	}

	public synchronized Resource getResourceFromNameAndType(Hashtable ht) {
		Iterator it = objects.iterator();
		while (it.hasNext()) {
			// 取得实体
			Entity entity = (Entity) it.next();
			// 判断实体是否是资源
			if (entity instanceof Resource) {
				Resource resource = (Resource) entity;
				String name = (String) resource.getAttributes().get("name");
				String type = (String) resource.getAttributes().get(
						"resourcetype");
//				if (name == null || type == null) {
//					throw new RuntimeException("资源名称或者类型为空:"
//							+ resource.getAttributes().toString());
//				}
				if (name.toString().equals(ht.get("name"))
						&& type.toString().equals(ht.get("resourcetype"))) {
					return resource;
				}
			}
		}
		return null;
	}

	/**
	 * 得到所有用户
	 * 
	 * @return 所有用户链表
	 */
	public synchronized LinkedList getUsers() {
		LinkedList list = new LinkedList();
		Iterator ite = this.objects.iterator();
		while (ite.hasNext()) {
			Entity entity = (Entity) ite.next();
			if (entity instanceof Resource) {
				Resource re = (Resource) entity;
				if (re instanceof User) {
					list.add(re);
				}
			}
		}
		return list;
	}

	/**
	 * 根据用户中文名称得到用户
	 * 
	 * @param name
	 * @return LinkedList
	 */
	public synchronized LinkedList getUserFromCname(String name) {
		// 符合条件的用户连表
		LinkedList result = new LinkedList();
		LinkedList users = getUsers();
		for (int i = 0; i < users.size(); i++) {
			Resource user = (Resource) users.get(i);
			try {
				String cname = user.getAttributes().get("name").toString();
				if (cname.equals(name)) {
					result.add(user);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return result;
	}

	/**
	 * 根据用户中文名称得到用户,实现模糊查找查询
	 * 
	 * @param name
	 * @return LinkedList
	 */
	public synchronized LinkedList getUserFromCnameWithBlurSearch(String name) {
		// 符合条件的用户连表
		LinkedList result = new LinkedList();
		LinkedList users = getUsers();
		for (int i = 0; i < users.size(); i++) {
			Resource user = (Resource) users.get(i);
			try {
				String cname = user.getAttributes().get("name").toString();
				if (cname.indexOf(name) != -1) {
					result.add(user);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return result;
	}

	/**
	 * 根据角色名得到该角色下的所有用户
	 * 
	 * @return
	 */
	public synchronized LinkedList getUserForRoleName(String roleName) {
		LinkedList result = new LinkedList();
		// 得到所有用户
		Hashtable ht = this.getAllUser();
		Collection coll = ht.values();
		Iterator iter = coll.iterator();
		// 为了得到该角色下的所有用户
		while (iter.hasNext()) {
			// 得到用户
			User user = (User) iter.next();
			if (this.isUserBelongThisRole(roleName, user)) {
				result.add(user);
			}
		}
		return result;
	}

	/**
	 * 判断某个用户是否属于这个角色
	 * 
	 * @param roleName
	 *            角色名
	 * @param user 用户
	 * @return boolean
	 */
	public synchronized boolean isUserBelongThisRole(String roleName, User user) {
		// 取出用户的所有角色
		LinkedList list = user.getRoles();
		Iterator iter = list.iterator();
		// 为了判断该用户是否属于该角色
		while (iter.hasNext()) {
			// 得到角色名
			String name = (String) iter.next();
			// 如果该用户属于该角色
			if (name.equals(roleName)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 得到管理器自己
	 */
	public static EntityManager getInstance() {
		return self;
	}

	/**
	 * 得到列表中所有对象的id,组织成以","分割的串
	 */
	public static String getAllID(LinkedList list) {
		LinkedList result = new LinkedList();
		Iterator iter = list.iterator();
		while (iter.hasNext()) {
			Entity item = (Entity) iter.next();
			result.add(item.getID());
		}
		return Tools.LinkedListTostring(result);
	}

	/**
	 * 根据以","分割的ID串得到所有对象列表
	 */
	public static LinkedList getEntities(String allID) {
		LinkedList result = new LinkedList();
		// 把字符串转换成字符串列表
		LinkedList list = Tools.stringToLinkedList(allID);
		// 对于每一个ID
		Iterator iter = list.iterator();
		while (iter.hasNext()) {
			String item = (String) iter.next();
			Object obj = EntityManager.getInstance().getObject(item);
			// 如果有改对象
			if (obj != null) {
				// 把所对应的对象添加到结果中
				result.add(EntityManager.getInstance().getObject(item));
			}
		}
		return result;
	}

	/**
	 * 得到要显示的列的数据
	 */
	public static String getValue(Entity entity, String name) throws Exception {
		String value = (String) entity.getAttributes().get(name);
		// 如果数据为空
		if (value == null || value.equals("")) {
			// 返回空白
			return "??";
		}
		// 否则，返回数据
		return value;
	}

	/**
	 * 按分页方式从数据库中装载对象，不存入对象管理器中
	 * 
	 * @param tableName
	 *            表名
	 * @param entityType
	 *            实体类型
	 * @param start
	 *            开始行号
	 * @param end
	 *            结束行号
	 * @param condition
	 *            条件
	 * @return 装载的对象
	 */
	private Collection loadObjects(String tableName, String className,
			String entityType, int start, int end, String condition) {
		try {
			// 如果是Oracle
			String sqlstate = PropertiesService.getProperty("Database",
					"SQLStatement");
			if (sqlstate.equals("com.browsesoft.oracle.OracleStatement")
					|| sqlstate
							.equals("com.browsesoft.sqlserver.SQLServerStatement")) {
				// 得到sql语句
				String sql = this.getOraclePageSQL(tableName, entityType,
						condition);
				String data[][] = DBTools.executePageQueryWithTableHead(sql,
						start, end);
				return ObjectHelper.newObjects(data, className);
			}
			// 否则，是Mysql
			else {
				// 得到数据
				String sql = "select * from " + tableName;
				// 添加条件
				String entityCondition = "entitytype='" + entityType + "'";
				String con = DBTools.connectCondition(entityCondition,
						condition);
				sql += " where " + con + " LIMIT " + start + ","
						+ (end - start);
				String data[][] = DBTools.executeQueryWithTableHead(sql);
				return ObjectHelper.newObjects(data, className);
			}
		} catch (SQLException e) {
			System.out.println(e.getMessage());
			return new LinkedList();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 按分页方式从数据库中装载对象，不存入对象管理器中，有排序方式
	 * 
	 * @param tableName
	 *            表名
	 * @param entityType
	 *            实体类型
	 * @param start
	 *            开始行号
	 * @param end
	 *            结束行号
	 * @param condition
	 *            条件
	 * @return 装载的对象
	 */
	private Collection loadObjects(String tableName, String className,
			String entityType, int start, int end, String condition,
			String order) {
		try {
			// 如果是Oracle
			String sqlstate = PropertiesService.getProperty("Database",
					"SQLStatement");
			if (sqlstate.equals("com.browsesoft.oracle.OracleStatement")
					|| sqlstate
							.equals("com.browsesoft.sqlserver.SQLServerStatement")) {
				// 得到sql语句
				String sql = this.getOraclePageSQLWithOrder(tableName,
						entityType, condition, order);
				String data[][] = DBTools.executePageQueryWithTableHead(sql,
						start, end);
				return ObjectHelper.newObjects(data, className);
			}
			// 否则，是Mysql
			else {
				// 得到数据
				String sql = "select * from " + tableName;
				// 添加条件
				String entityCondition = "entitytype='" + entityType + "'";
				String con = DBTools.connectCondition(entityCondition,
						condition);
				sql += " where " + con;
				// 如果有排序条件
				if (order != null && !order.equals("")) {
					// 添加排序条件
					sql += " order by " + order;
				}
				sql += " LIMIT " + start + "," + (end - start);
				String data[][] = DBTools.executeQueryWithTableHead(sql);
				return ObjectHelper.newObjects(data, className);
			}
		} catch (SQLException e) {
			System.out.println(e.getMessage());
			return new LinkedList();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 根据给定的值产生Oracle中的查询语句
	 * 
	 * @param tableName
	 *            表名
	 * @param entityType
	 *            实体类型
	 * @param condition
	 *            条件
	 * @param num
	 *            行号
	 */
	private String getOraclePageSQL(String tableName, String entityType,
			String condition) {
		// 添加条件
		String entityCondition = "entitytype='" + entityType + "'";
		// 组合条件
		String con = DBTools.connectCondition(entityCondition, condition);
		return "select * from " + tableName + " where " + con;
	}

	/**
	 * 根据给定的值产生Oracle中的查询语句
	 * 
	 * @param tableName
	 *            表名
	 * @param entityType
	 *            实体类型
	 * @param condition
	 *            条件
	 * @param num
	 *            行号
	 */
	private String getOraclePageSQLWithOrder(String tableName,
			String entityType, String condition, String order) {
		// 添加条件
		String entityCondition = "entitytype='" + entityType + "'";
		// 组合条件
		String con = DBTools.connectCondition(entityCondition, condition);
		String sql = "select * from " + tableName + " where " + con;
		// 如果有排序条件
		if (order != null && !order.equals("")) {
			// 添加排序条件
			sql += " order by " + order;
		}
		return sql;
	}

	/**
	 * 插入对象，只往数据库中添加，不向管理器中添加
	 * 
	 * @param entity
	 *            要插入的实体对象
	 * @param createTable
	 *            是否创建数据库结构
	 */
	public void insertToDB(Entity entity, boolean createTable) {
		try {
			// 得到表名
			String tableName = this.getTableName(entity);
			// 如果创建数据库
			if (createTable) {
				// 写库
				DBTools.insert(tableName, entity.getAttributes());
			} else {
				// 从实体类型中得到字段类型
				String typeName = (String) entity.getAttributes().get(
						"entitytype");
				EntityType entityType = EntityTypeFactory.getInstance()
						.getEntityType(typeName);
				Hashtable fieldTypes = (Hashtable) entityType.getFieldTypes();
				// 不带建立表结构的写库
				DBTools.insertNoCreateTable(tableName, entity.getAttributes(),
						fieldTypes);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 根据实体得到表名
	 * 
	 * @param entity
	 *            实体
	 * @return 表名
	 */
	public String getTableName(Entity entity) {
		// 从实体属性中得到表名
		String tableName = entity.getTableName();
		// 如果存在
		if (tableName != null && !tableName.equals("")) {
			// 返回
			return tableName;
		}
		// 从实体类型中得到表名
		String typeName = (String) entity.getAttributes().get("entitytype");
		EntityType entityType = EntityTypeFactory.getInstance().getEntityType(
				typeName);
		return entityType.getTableName();
	}

	/**
	 * 插入对象，只往数据库中添加，不向管理器中添加，建立表结构
	 * 
	 * @param entity
	 *            要插入的实体对象
	 */
	public void insertToDB(Entity entity) {
		this.insertToDB(entity, true);
	}

	/**
	 * 把实体存入数据库
	 * 
	 * @param entity
	 *            要存的实体
	 * @param createTable
	 *            是否创建表结构
	 */
	public void update(Entity entity, boolean createTable) {
		try {
			// 得到实体类型，数据库表名等数据
			String typeName = (String) entity.getAttributes().get("entitytype");
			EntityType entityType = EntityTypeFactory.getInstance()
					.getEntityType(typeName);
			String tableName = entityType.getTableName();
			// 如果创建数据库
			if (createTable) {
				// 写库
				DBTools.update(tableName, entity.getID(), entity
						.getAttributes());
			} else {
				Hashtable fieldTypes = (Hashtable) entityType.getFieldTypes();
				// 不带建立表结构的写库
				DBTools.updateNoCreateTable(tableName, entity.getID(), entity
						.getAttributes(), fieldTypes);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 不带条件更新某类实体的所有对象的某个属性值
	 * 
	 * @param entityType
	 *            字符串表示的实体类型
	 * @param attrName
	 *            属性名
	 * @param attrValue
	 *            属性值
	 */
	public void updateEntities(String entityType, String attrName,
			String attrValue, HTMLPage request) {
		this.updateEntities(entityType, attrName, attrValue, new HashMap(),
				request);
	}

	/**
	 * 根据条件更新某类实体的所有对象的某个属性值
	 * 
	 * @param entityType
	 *            字符串表示的实体类型
	 * @param attrName
	 *            属性名
	 * @param attrValue
	 *            属性值
	 */
	public void updateEntities(String entityType, String attrName,
			String attrValue, Map condition, HTMLPage request) {
		// 根据请求得到管理器
		Iterator iter = this.getManager(request).iterator();
		while (iter.hasNext()) {
			Entity findObj = (Entity) iter.next();
			// 如果是要修改的实体
			if (this.isSame(findObj, condition)) {
				// 设置实体属性
				findObj.getAttributes().put(attrName, attrValue);
			}
		}
		try {
			// 根据实体类型得到表名
			EntityType type = EntityTypeFactory.getInstance().getEntityType(
					entityType);
			String tableName = type.getTableName();
			// 使用sql语句批量更新
			String qcon = DBTools.hashtableToSQLCondition(condition, false);
			qcon = DBTools.connectCondition(qcon, "entitytype='" + entityType
					+ "'");
			String sql = "update " + tableName + " set " + attrName + "='"
					+ attrValue + "' where " + qcon;
			DBTools.excuteUpdate(sql);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 把实体存入数据库，一定建表结构
	 * 
	 * @param entity
	 *            要存的实体
	 */
	public void update(Entity entity) {
		this.update(entity, true);
	}

	/**
	 * 添加一个事后处理对象
	 * 
	 * @param entity
	 *            事后处理对象
	 */
	public void addComplete(Complete entity) {
		this.completes.add(entity);
	}

	/**
	 * 清空所有事后处理对象
	 */
	public void clearComplete() {
		this.completes.clear();
	}

	/**
	 * 得到所有事后处理对象
	 * 
	 * @return 事后处理对象列表
	 */
	public Iterator getCompletes() {
		return this.completes.iterator();
	}

	/**
	 * 查询结果所对应的迭代器
	 */
	private class EntityIterator implements Iterator {
		/**
		 * 查询的结果集
		 */
		private ResultSet set = null;

		/**
		 * 对应的对象类名
		 */
		private String className = null;

		/**
		 * 列名数组
		 */
		private String[] colNames = null;

		/**
		 * 是否还有内容
		 */
		private boolean hasNext = true;

		/**
		 * 使用结果集构造
		 * 
		 * @param set
		 *            结果集
		 */
		public EntityIterator(ResultSet set, String className) {
			try {
				this.set = set;
				this.className = className;
				// 得到列名
				this.colNames = DBTools.getColNames(this.set);
				this.hasNext = this.set.next();
			} catch (SQLException ex) {
				throw new RuntimeException(ex);
			}
		}

		/**
		 * 看是否有下一个对象
		 */
		public boolean hasNext() {
			return this.hasNext;
		}

		/**
		 * 得到下一个对象
		 */
		public Object next() {
			try {
				// 从结果集中得到对象
				String[] datas = DBTools.getOneRecord(this.set,
						this.colNames.length);
				Map map = this.datasToMap(datas);
				// 到下一条记录
				this.hasNext = this.set.next();
				// 返回构造出来的对象
				return newObject(this.className, new Hashtable(map));
			} catch (SQLException ex) {
				throw new RuntimeException(ex);
			}
		}

		/**
		 * 移走一个对象
		 */
		public void remove() {
		}

		/**
		 * 把数据依照字段名转换成map
		 * 
		 * @param datas
		 *            数据
		 * @return 以map形式表现的属性以及值
		 */
		private Map datasToMap(String[] datas) {
			Map result = new HashMap();
			// 对于每一个字段
			for (int i = 0; i < this.colNames.length; i++) {
				// 如果数据中有空值
				if (datas[i] == null) {
					datas[i] = "";
				}
				// 把属性名以及值放到结果中
				result.put(this.colNames[i].toLowerCase(), datas[i]);
			}
			return result;
		}
	}

	/**
	 * 在直接对数据库进行完批量处理后，对延迟加载中的已装载对象进行更新
	 * 
	 * @param className
	 *            要更新的对象类型
	 */
	public void reload(String className, HTMLPage request) {
		// 根据请求得到管理器
		Iterator iter = this.getManager(request).iterator();
		// 对于已装载区的每一个对象
		while (iter.hasNext()) {
			Entity entity = (Entity) iter.next();
			// 如果是与给定类型相同
			if (entity != null && entity.getClass().getName().equals(className)) {
				// 重新装载该对象
				this.reload(entity);
			}
		}
	}

	/**
	 * 从数据库中重新装载对象
	 * 
	 * @param entity
	 *            要重新装载的对象
	 */
	public void reload(Entity entity) {
		try {
			// 从数据库中得到该对象的最新属性
			String tableName = (String) entity.getAttributes().get("tablename");
			String sql = "select * from " + tableName + " where id="
					+ entity.getID();
			String[][] datas = DBTools.executeQueryWithTableHead(sql);
			// 设置实体属性
			Hashtable attrs = entity.getAttributes();
			attrs.clear();
			attrs.putAll(DBTools.getAttributes(datas, 1));
		} catch (Exception ex) {
		}
	}

	/**
	 * 得到给定用户得角色名称 ◎param user 用户
	 */
	public synchronized LinkedList getRolesOfUser(User user) {
		LinkedList result = new LinkedList();
		// 得到所有角色
		LinkedList list = this.getAllRoles();
		Iterator iter = list.iterator();
		while (iter.hasNext()) {
			Role role = (Role) iter.next();
			// 得到该角色得用户名单
			String userIDS = (String) role.getAttributes().get("users");
			// 如果有
			if (userIDS != null && !userIDS.equals("")) {
				// 如果该教色包含该用户
				if (userIDS.indexOf(user.getID()) != -1) {
					result.add(role);
				}
			}
		}
		return result;
	}

	public void synchronAdd(String className, Hashtable attributes) {
		Entity entity = (Entity) newObject(className, attributes);
		entity.createRelation();
		this.add(entity);
	}

	public User getUser(String inputName, String inputPass, boolean isCase) {
		// 取得加密器,对输入的密码加密
		EncryptMachine em = GetEncryptMachineTool.getEncryptMachine();
		Iterator iter = this.objects.iterator();
		while (iter.hasNext()) {
			Entity entity = (Entity) iter.next();
			if (entity instanceof User) {
				String userName = (String) entity.getAttributes().get("ename");
				if (!userName.equals(inputName)) {
					continue;
				}
				String userPassword = (String) entity.getAttributes().get(
						"password");
				if (isCase) {
					inputPass = em.getEncryptData(inputPass, "userpassword");
					if (inputPass.equals(userPassword)) {
						return (User) entity;
					}
				} else {
					String small = em.getEncryptData(inputPass, "userpassword");
					String big = em.getEncryptData(inputPass.toUpperCase(),
							"userpassword");
					// 如果不相等,返会false
					if (small.equals(userPassword) || big.equals(userPassword)) {
						return (User) entity;
					}
				}
			}
		}
		return null;
	}

	//对用户进行上密码认证
	public User getUser(String inputName, String inputPass, String inputPass2, boolean isCase) {
		// 取得加密器,对输入的密码加密
		EncryptMachine em = GetEncryptMachineTool.getEncryptMachine();
		Iterator iter = this.objects.iterator();
		while (iter.hasNext()) {
			Entity entity = (Entity) iter.next();
			if (entity instanceof User) {
				String userName = (String) entity.getAttributes().get("ename");
				if (!userName.equals(inputName)) {
					continue;
				}
				String userPassword = (String) entity.getAttributes().get(
						"password");
				String userPassword2 = (String) entity.getAttributes().get("password2");
				if (isCase) {
					inputPass = em.getEncryptData(inputPass, "userpassword");
					inputPass2 = em.getEncryptData(inputPass2, "userpassword");
					if (inputPass.equals(userPassword) && inputPass2.equals(userPassword2)) {
						return (User) entity;
					}
				} else {
					String small = em.getEncryptData(inputPass, "userpassword");
					String big = em.getEncryptData(inputPass.toUpperCase(),
							"userpassword");
					String small2 = em.getEncryptData(inputPass2, "userpassword");
					String big2 = em.getEncryptData(inputPass2.toUpperCase(), "userpassword");
					// 如果不相等,返会false
					if ((small.equals(userPassword) || big.equals(userPassword)) &&
							(small2.equals(userPassword2) || big2.equals(userPassword2))) {
						return (User) entity;
					}
				}
			}
		}
		return null;
	}

	public User getUserById(String id) {
		return (User)this.getObject(id);
	}
	
	public void synchronRemove(String id) {
		Entity entity = (Entity) this.getObject(id);
		entity.sychronDelete();
	}

	public void synchronUpdate(String id, Hashtable attributes) {
		Entity entity = (Entity) this.getObject(id);
		entity.sychronUpdate(attributes);
	}

}

/**
 * 根据属性，对二维数组中的数据按照数字方式比较大小
 */
class NumberComparator implements Comparator {
	/**
	 * 要排序的属性
	 */
	private int col = 0;

	/**
	 * 使用要排序的属性名构造
	 * 
	 * @param name
	 *            要排序的属性名
	 */
	public NumberComparator(int col) {
		this.col = col;
	}

	/**
	 * 两个对象进行比价
	 */
	public int compare(Object o1, Object o2) {
		try {
			String[] s1 = (String[]) o1;
			String[] s2 = (String[]) o2;
			return Integer.parseInt(s1[col]) - Integer.parseInt(s2[col]);
		} catch (Exception e) {
			return 0;
		}
	}

	/**
	 * 判断是否相等
	 */
	public boolean equals(Object obj) {
		return false;
	}
}
